home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / WINDOWS / TVCACHE.ZIP / VCASM.ASM < prev    next >
Encoding:
Assembly Source File  |  1996-01-05  |  6.7 KB  |  396 lines

  1. ;======================================================================
  2. ; VCASM.asm    
  3. ;
  4. ; Copyright (c) 1995 Mark Russinovich and Bryce Cogswell    
  5. ;
  6. ; This file contains the assembly language interface wrappers for
  7. ; tvcache. Note that register save/restores were determined
  8. ; many times through actual monitoring of the real vcache's usage.
  9. ;
  10. ;======================================================================
  11. .386p
  12.     NO_SEGMENTS=1
  13.     include vmm.inc
  14.     include vsegment.inc
  15. .list
  16.  
  17. VXD_LOCKED_DATA_SEG
  18.  
  19.  
  20. VXD_LOCKED_DATA_ENDS
  21.  
  22. VXD_LOCKED_CODE_SEG
  23.  
  24.     extern    _CTVCACHE_Get_Version    : near
  25.     extern    _CTVCACHE_Register    : near
  26.     extern    _CTVCACHE_GetSize    : near
  27.     extern    _CTVCACHE_CheckAvail    : near
  28.     extern    _CTVCACHE_FindBlock    : near
  29.     extern    _CTVCACHE_FreeBlock    : near
  30.     extern    _CTVCACHE_MakeMRU    : near
  31.     extern    _CTVCACHE_Hold        : near
  32.     extern    _CTVCACHE_Unhold    : near
  33.     extern    _CTVCACHE_Enum        : near
  34.     extern    _CTVCACHE_TestHold    : near
  35.     extern    _CTVCACHE_GetStats    : near
  36.     extern    _CTVCACHE_Deregister    : near
  37.     extern    _CTVCACHE_SwapBuffers    : near
  38.     extern    _CTVCACHE_RelinquishPage: near
  39.     extern    _CTVCACHE_UseThisPage    : near
  40.     extern    _CTVCACHE_AdjustMinimum    : near
  41.  
  42.  
  43.  
  44. BeginProc _TVCache_Get_Version
  45.     push    ecx
  46.     push    edx
  47.     call    _CTVCACHE_Get_Version
  48.     xor    ebx, ebx
  49.     clc
  50.     pop    edx
  51.     pop    ecx
  52.     ret
  53. EndProc _TVCache_Get_Version
  54.  
  55.  
  56. BeginProc _TVCache_Register
  57.     push    ecx
  58.     push    edx
  59.     push    ecx            ; nblocks
  60.     push    esi            ; buffer discard proc
  61.     call    _CTVCACHE_Register
  62.     add    esp, 8
  63.     pop    edx
  64.     pop    ecx
  65.     ret                ; eax = fsd id
  66. EndProc _TVCache_Register
  67.  
  68.  
  69. BeginProc _TVCache_GetSize
  70.     push    edi
  71.     push    esi
  72.     push    ebp
  73.     mov    ebp, esp
  74.     sub    esp, 8            ; create space for returns
  75.     lea    edx, [ebp-4]
  76.     push    edx            ; pointer to minsize
  77.     lea    edx, [ebp-8]
  78.     push    edx            ; pointer to maxsize
  79.     movzx    eax, ah
  80.     push    eax            ; fsd id
  81.     call    _CTVCACHE_GetSize
  82.     add    esp, 3*4        ; eax = cursize
  83.     pop    edx            ; maxsize
  84.     pop    ecx            ; minsize
  85.     pop    ebp
  86.     pop    esi
  87.     pop    edi
  88.     ret
  89. EndProc _TVCache_GetSize
  90.  
  91.  
  92. BeginProc _TVCache_CheckAvail
  93.     push    ecx
  94.     push    ecx
  95.     movzx    eax, ah    
  96.     push    eax
  97.     call    _CTVCACHE_CheckAvail
  98.     add    esp, 8
  99.     pop    ecx
  100.     cmp    eax, ecx
  101.     ret
  102. EndProc _TVCache_CheckAvail
  103.  
  104.  
  105. BeginProc _TVCache_FindBlock
  106.     push    edx
  107.     push    ecx
  108.     push    ebp
  109.     mov    ebp, esp
  110.     sub    esp, 12            ; create space for returns
  111.     lea    edx, [ebp-4]
  112.     push    edx            ; pointer to buffer address
  113.     lea    edx, [ebp-8]
  114.     push    edx            ; pointer to cache locked    
  115.     lea    edx, [ebp-12]
  116.     push    edx            ; pointer to cache block
  117.     push    edi            ; key 2
  118.     push    ebx            ; key 1
  119.     movzx    edx, al            ; flags
  120.     push    edx
  121.     movzx    edx, ah            ; fsd id
  122.     push    edx
  123.     call    _CTVCACHE_FindBlock
  124.     mov    edx, eax
  125.     add    esp, 7*4        ; pop off fsdid, opt, key1, key2
  126.     pop    esi            ; cache block handle
  127.     pop    ecx            ; block is locked (BOOL)
  128.     pop    eax            ; buffer address
  129.     mov    esp, ebp
  130.     pop    ebp
  131.  
  132.     ; set up the flags
  133.  
  134.     cmp    edx, 1
  135.     jnz    notfound
  136.     neg    ecx            ; clear zero flag if locked
  137.     clc
  138.     pop    ecx
  139.     pop    edx
  140.     ret
  141.             
  142. notfound:    
  143.     neg    ecx            ; clear zero flag if locked
  144.     stc
  145.     pop    ecx
  146.     pop    edx
  147.     ret
  148. EndProc _TVCache_FindBlock
  149.  
  150.  
  151. BeginProc _TVCache_FreeBlock
  152.     pusha
  153.     push    esi
  154.     call    _CTVCACHE_FreeBlock
  155.     add    esp, 4
  156.     popa
  157.     ret
  158. EndProc _TVCache_FreeBlock
  159.  
  160.  
  161. BeginProc _TVCache_MakeMRU
  162.     pusha
  163.     push    esi
  164.     call    _CTVCACHE_MakeMRU
  165.     add    esp, 4
  166.     popa
  167.     ret
  168. EndProc _TVCache_MakeMRU
  169.  
  170.  
  171. BeginProc _TVCache_Hold
  172.     pusha
  173.     pushfd
  174.     push    esi
  175.     call    _CTVCACHE_Hold
  176.     add    esp, 4
  177.     popfd
  178.     inc    eax
  179.     popa
  180.     ret
  181. EndProc _TVCache_Hold
  182.  
  183.  
  184. BeginProc _TVCache_Unhold
  185.     pusha
  186.     pushfd
  187.     push    esi
  188.     call    _CTVCACHE_Unhold
  189.     add    esp, 4
  190.     popfd
  191.     dec    eax
  192.     popa
  193.     ret
  194. EndProc _TVCache_Unhold
  195.  
  196.  
  197. BeginProc _TVCache_Enum
  198.     pusha
  199.     push    ebp            ; ref 3
  200.     push    ecx            ; ref 2
  201.     push    ebx            ; ref 1
  202.     push    edx            ; callback function
  203.     movzx    eax, ah
  204.     push    eax            ; fsd id
  205.     call    _CTVCACHE_Enum
  206.     add    esp, 20
  207.     popa
  208.     ret
  209. EndProc _TVCache_Enum
  210.  
  211.  
  212. BeginProc _TVCache_TestHandle
  213.     ret
  214. EndProc _TVCache_TestHandle
  215.  
  216.  
  217. BeginProc _TVCache_VerifySums
  218.     ret
  219. EndProc _TVCache_VerifySums
  220.  
  221.  
  222. BeginProc _TVCache_RecalcSums
  223.     ret
  224. EndProc _TVCache_RecalcSums
  225.  
  226.  
  227. BeginProc _TVCache_TestHold    
  228.     push    ecx
  229.     push    edx
  230.     push    esi
  231.     push    edi
  232.     push    esi
  233.     call    _CTVCACHE_TestHold
  234.     add    esp, 4
  235.     or    eax, eax
  236.     pop    edi
  237.     pop    esi
  238.     pop    edx
  239.     pop    ecx
  240.     ret
  241. EndProc _TVCache_TestHold
  242.  
  243.  
  244. BeginProc _TVCache_GetStats
  245.     push    eax
  246.     push    ebp
  247.     push    esi
  248.     mov    ebp, esp
  249.     sub    esp, 16
  250.     lea    eax, [ebp-4]        ; discarded blocks
  251.     push    eax
  252.     lea    eax, [ebp-8]        ; base address
  253.     push    eax
  254.     lea    eax, [ebp-12]        ; hits
  255.     push    eax
  256.     lea    eax, [ebp-16]        ; misses
  257.     push    eax
  258.     call    _CTVCACHE_GetStats
  259.     add    esp, 16
  260.     pop    ebx            ; misses
  261.     pop    ecx            ; hits
  262.     pop    edx            ; base
  263.     pop    edi            ; discards
  264.     mov    esp, ebp
  265.     pop    esi
  266.     pop    ebp
  267.     pop    eax
  268.     ret
  269. EndProc _TVCache_GetStats
  270.  
  271.  
  272. BeginProc _TVCache_Deregister
  273.     pusha
  274.     push    eax
  275.     call    _CTVCACHE_Deregister
  276.     add    esp, 4
  277.     popa
  278.     ret
  279. EndProc _TVCache_Deregister
  280.  
  281.  
  282. BeginProc _TVCache_AdjustMinimum
  283.     movzx   eax, ah            ; fsd id
  284.     push    eax
  285.     push    ecx            ; quota
  286.     call    _CTVCACHE_AdjustMinimum
  287.     add    esp, 8
  288.     cmp    eax, 1
  289.     ret
  290. EndProc _TVCache_AdjustMinimum
  291.  
  292.  
  293. BeginProc _TVCache_SwapBuffers
  294.     pusha
  295.     push    edi
  296.     push    esi
  297.     call    _CTVCACHE_SwapBuffers
  298.     add    esp, 8
  299.     cmp    eax, 1
  300.     popa
  301.     ret
  302. EndProc _TVCache_SwapBuffers
  303.  
  304.  
  305. BeginProc _TVCache_RelinquishPage
  306.     push    ecx
  307.     push    edx
  308.     call    _CTVCACHE_RelinquishPage
  309.     pop    edx
  310.     pop    ecx
  311.     ret
  312. EndProc _TVCache_RelinquishPage
  313.  
  314.  
  315. BeginProc _TVCache_UseThisPage
  316.     pusha
  317.     push    eax
  318.     call    _CTVCACHE_UseThisPage
  319.     add    esp, 4
  320.     popa
  321.     ret
  322. EndProc _TVCache_UseThisPage
  323.  
  324. ;----------------------------------------------------------------------
  325. ;
  326. ; EnumCallback
  327. ;
  328. ; This is the only non-API wrapper. It is used to call the specified
  329. ; callback during enum functions.
  330. ;
  331. ;----------------------------------------------------------------------
  332. Public EnumCallback
  333. EnumCallback PROC C USES eax ebx ecx edx esi edi ebp,
  334.     callback: DWORD,
  335.     blockid : DWORD,
  336.     refebx  : DWORD,
  337.     refecx  : DWORD,
  338.     refebp  : DWORD,
  339.     hold    : DWORD
  340.  
  341.     mov    esi, blockid
  342.     mov    edx, callback
  343.     mov    edi, hold
  344.     mov    eax, refebx
  345.     mov    ebx, [eax]
  346.     mov    eax, refecx
  347.     mov    ecx, [eax]
  348.     mov    eax, refebp
  349.     push    ebp
  350.     mov    ebp, [eax]
  351.     cmp    edi, 1
  352.     
  353.     ; make the call
  354.  
  355.     call    edx
  356.     
  357.     mov    edx, ebp
  358.     pop    ebp
  359.     mov    eax, refebp
  360.     mov    [eax], edx
  361.     mov    eax, refebx
  362.     mov    [eax], ebx
  363.     mov    eax, refecx
  364.     mov    [eax], ecx
  365.     ret
  366.     
  367. EnumCallback ENDP
  368.  
  369.  
  370. BeginProc __TVCache_CreateLookupCache
  371.     xor    eax, eax
  372.     ret
  373. EndProc __TVCache_CreateLookupCache
  374.  
  375. BeginProc  __TVCache_CloseLookupCache
  376.     ret
  377. EndProc  __TVCache_CloseLookupCache
  378.  
  379. BeginProc  __TVCache_DeleteLookupCache
  380.     ret
  381. EndProc  __TVCache_DeleteLookupCache
  382.  
  383. BeginProc  __TVCache_Lookup
  384.     ret
  385. EndProc  __TVCache_Lookup
  386.  
  387. BeginProc  __TVCache_UpdateLookup
  388.     ret
  389. EndProc  __TVCache_UpdateLookup
  390.  
  391.  
  392.  
  393. VXD_LOCKED_CODE_ENDS
  394.  
  395. end